home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / src / linux-headers-2.6.28-15 / include / asm-xtensa / tlbflush.h < prev    next >
Encoding:
C/C++ Source or Header  |  2008-12-24  |  4.9 KB  |  192 lines
  1. /*
  2.  * include/asm-xtensa/tlbflush.h
  3.  *
  4.  * This file is subject to the terms and conditions of the GNU General Public
  5.  * License.  See the file "COPYING" in the main directory of this archive
  6.  * for more details.
  7.  *
  8.  * Copyright (C) 2001 - 2005 Tensilica Inc.
  9.  */
  10.  
  11. #ifndef _XTENSA_TLBFLUSH_H
  12. #define _XTENSA_TLBFLUSH_H
  13.  
  14. #ifdef __KERNEL__
  15.  
  16. #include <linux/stringify.h>
  17. #include <asm/processor.h>
  18.  
  19. #define DTLB_WAY_PGD    7
  20.  
  21. #define ITLB_ARF_WAYS    4
  22. #define DTLB_ARF_WAYS    4
  23.  
  24. #define ITLB_HIT_BIT    3
  25. #define DTLB_HIT_BIT    4
  26.  
  27. #ifndef __ASSEMBLY__
  28.  
  29. /* TLB flushing:
  30.  *
  31.  *  - flush_tlb_all() flushes all processes TLB entries
  32.  *  - flush_tlb_mm(mm) flushes the specified mm context TLB entries
  33.  *  - flush_tlb_page(mm, vmaddr) flushes a single page
  34.  *  - flush_tlb_range(mm, start, end) flushes a range of pages
  35.  */
  36.  
  37. extern void flush_tlb_all(void);
  38. extern void flush_tlb_mm(struct mm_struct*);
  39. extern void flush_tlb_page(struct vm_area_struct*,unsigned long);
  40. extern void flush_tlb_range(struct vm_area_struct*,unsigned long,unsigned long);
  41.  
  42. #define flush_tlb_kernel_range(start,end) flush_tlb_all()
  43.  
  44. /* TLB operations. */
  45.  
  46. static inline unsigned long itlb_probe(unsigned long addr)
  47. {
  48.     unsigned long tmp;
  49.     __asm__ __volatile__("pitlb  %0, %1\n\t" : "=a" (tmp) : "a" (addr));
  50.     return tmp;
  51. }
  52.  
  53. static inline unsigned long dtlb_probe(unsigned long addr)
  54. {
  55.     unsigned long tmp;
  56.     __asm__ __volatile__("pdtlb  %0, %1\n\t" : "=a" (tmp) : "a" (addr));
  57.     return tmp;
  58. }
  59.  
  60. static inline void invalidate_itlb_entry (unsigned long probe)
  61. {
  62.     __asm__ __volatile__("iitlb  %0; isync\n\t" : : "a" (probe));
  63. }
  64.  
  65. static inline void invalidate_dtlb_entry (unsigned long probe)
  66. {
  67.     __asm__ __volatile__("idtlb  %0; dsync\n\t" : : "a" (probe));
  68. }
  69.  
  70. /* Use the .._no_isync functions with caution.  Generally, these are
  71.  * handy for bulk invalidates followed by a single 'isync'.  The
  72.  * caller must follow up with an 'isync', which can be relatively
  73.  * expensive on some Xtensa implementations.
  74.  */
  75. static inline void invalidate_itlb_entry_no_isync (unsigned entry)
  76. {
  77.     /* Caller must follow up with 'isync'. */
  78.     __asm__ __volatile__ ("iitlb  %0\n" : : "a" (entry) );
  79. }
  80.  
  81. static inline void invalidate_dtlb_entry_no_isync (unsigned entry)
  82. {
  83.     /* Caller must follow up with 'isync'. */
  84.     __asm__ __volatile__ ("idtlb  %0\n" : : "a" (entry) );
  85. }
  86.  
  87. static inline void set_itlbcfg_register (unsigned long val)
  88. {
  89.     __asm__ __volatile__("wsr  %0, "__stringify(ITLBCFG)"\n\t" "isync\n\t"
  90.                  : : "a" (val));
  91. }
  92.  
  93. static inline void set_dtlbcfg_register (unsigned long val)
  94. {
  95.     __asm__ __volatile__("wsr  %0, "__stringify(DTLBCFG)"; dsync\n\t"
  96.                      : : "a" (val));
  97. }
  98.  
  99. static inline void set_ptevaddr_register (unsigned long val)
  100. {
  101.     __asm__ __volatile__(" wsr  %0, "__stringify(PTEVADDR)"; isync\n"
  102.                  : : "a" (val));
  103. }
  104.  
  105. static inline unsigned long read_ptevaddr_register (void)
  106. {
  107.     unsigned long tmp;
  108.     __asm__ __volatile__("rsr  %0, "__stringify(PTEVADDR)"\n\t" : "=a" (tmp));
  109.     return tmp;
  110. }
  111.  
  112. static inline void write_dtlb_entry (pte_t entry, int way)
  113. {
  114.     __asm__ __volatile__("wdtlb  %1, %0; dsync\n\t"
  115.                  : : "r" (way), "r" (entry) );
  116. }
  117.  
  118. static inline void write_itlb_entry (pte_t entry, int way)
  119. {
  120.     __asm__ __volatile__("witlb  %1, %0; isync\n\t"
  121.                          : : "r" (way), "r" (entry) );
  122. }
  123.  
  124. static inline void invalidate_page_directory (void)
  125. {
  126.     invalidate_dtlb_entry (DTLB_WAY_PGD);
  127.     invalidate_dtlb_entry (DTLB_WAY_PGD+1);
  128.     invalidate_dtlb_entry (DTLB_WAY_PGD+2);
  129. }
  130.  
  131. static inline void invalidate_itlb_mapping (unsigned address)
  132. {
  133.     unsigned long tlb_entry;
  134.     if (((tlb_entry = itlb_probe(address)) & (1 << ITLB_HIT_BIT)) != 0)
  135.         invalidate_itlb_entry(tlb_entry);
  136. }
  137.  
  138. static inline void invalidate_dtlb_mapping (unsigned address)
  139. {
  140.     unsigned long tlb_entry;
  141.     if (((tlb_entry = dtlb_probe(address)) & (1 << DTLB_HIT_BIT)) != 0)
  142.         invalidate_dtlb_entry(tlb_entry);
  143. }
  144.  
  145. #define check_pgt_cache()    do { } while (0)
  146.  
  147.  
  148. /*
  149.  * DO NOT USE THESE FUNCTIONS.  These instructions aren't part of the Xtensa
  150.  * ISA and exist only for test purposes..
  151.  * You may find it helpful for MMU debugging, however.
  152.  *
  153.  * 'at' is the unmodified input register
  154.  * 'as' is the output register, as follows (specific to the Linux config):
  155.  *
  156.  *      as[31..12] contain the virtual address
  157.  *      as[11..08] are meaningless
  158.  *      as[07..00] contain the asid
  159.  */
  160.  
  161. static inline unsigned long read_dtlb_virtual (int way)
  162. {
  163.     unsigned long tmp;
  164.     __asm__ __volatile__("rdtlb0  %0, %1\n\t" : "=a" (tmp), "+a" (way));
  165.     return tmp;
  166. }
  167.  
  168. static inline unsigned long read_dtlb_translation (int way)
  169. {
  170.     unsigned long tmp;
  171.     __asm__ __volatile__("rdtlb1  %0, %1\n\t" : "=a" (tmp), "+a" (way));
  172.     return tmp;
  173. }
  174.  
  175. static inline unsigned long read_itlb_virtual (int way)
  176. {
  177.     unsigned long tmp;
  178.     __asm__ __volatile__("ritlb0  %0, %1\n\t" : "=a" (tmp), "+a" (way));
  179.     return tmp;
  180. }
  181.  
  182. static inline unsigned long read_itlb_translation (int way)
  183. {
  184.     unsigned long tmp;
  185.     __asm__ __volatile__("ritlb1  %0, %1\n\t" : "=a" (tmp), "+a" (way));
  186.     return tmp;
  187. }
  188.  
  189. #endif    /* __ASSEMBLY__ */
  190. #endif    /* __KERNEL__ */
  191. #endif    /* _XTENSA_TLBFLUSH_H */
  192.